home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / mawk.zip / FIN.C < prev    next >
C/C++ Source or Header  |  1991-04-07  |  9KB  |  369 lines
  1.  
  2. /********************************************
  3. fin.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the Awk programming language as defined in
  8. Aho, Kernighan and Weinberger, The AWK Programming Language,
  9. Addison-Wesley, 1988.
  10.  
  11. See the accompaning file, LIMITATIONS, for restrictions
  12. regarding modification and redistribution of this
  13. program in source or binary form.
  14. ********************************************/
  15.  
  16. /*$Log:    fin.c,v $
  17.  * Revision 2.1  91/04/08  08:23:09  brennan
  18.  * VERSION 0.97
  19.  * 
  20. */
  21.  
  22. /* fin.c */
  23.  
  24. #include "mawk.h"
  25. #include "fin.h"
  26. #include "memory.h"
  27. #include "bi_vars.h"
  28. #include "field.h"
  29. #include "symtype.h"
  30. #include "scan.h"
  31. #include <fcntl.h>
  32.  
  33. extern int errno ;
  34. int PROTO(isatty, (int) ) ;
  35. FILE *PROTO(fdopen, (int, char*) ) ;
  36.  
  37. /* statics */
  38. int  PROTO( next_main, (void) ) ;
  39. int  PROTO( is_cmdline_assign, (char *) ) ;
  40.  
  41. FIN  *FINdopen( fd, main_flag )
  42.   int fd , main_flag ;
  43. { register FIN *fin = (FIN *) zmalloc( sizeof(FIN) ) ;
  44.  
  45.   fin->fd = fd ;
  46.  
  47.   if ( main_flag )
  48.   { fin->flags = MAIN_FLAG ;
  49.     fin->buffp = fin->buff = main_buff ;
  50.   }
  51.   else
  52.   { 
  53.     fin->flags = 0 ;
  54.     fin->buffp = fin->buff = (char *) zmalloc(BUFFSZ+1) ;
  55.   }
  56.   *fin->buffp = 0 ;
  57.  
  58.   if ( isatty(fd) && rs_shadow.type == SEP_CHAR 
  59.        && rs_shadow.c == '\n' )
  60.   {
  61.     /* interactive, i.e., line buffer this file */
  62.     if ( fd == 0 ) fin->fp = stdin ;
  63.     else
  64.     if ( !(fin->fp = fdopen(fd, "r")) )
  65.     { errmsg(errno, "fdopen failed") ; exit(1) ; }
  66.   }
  67.   else  fin->fp = (FILE *) 0 ;
  68.  
  69.   return fin ;
  70. }
  71.  
  72. FIN  *FINopen( filename, main_flag )
  73.   char *filename ;
  74.   int main_flag ;
  75. { int fd ;
  76.  
  77.   if ( (fd = open( filename , O_RDONLY, 0 )) == -1 )
  78.   { errmsg( errno, "cannot open %s" , filename ) ;
  79.     return (FIN *) 0 ; }
  80.  
  81.   else  return  FINdopen( fd, main_flag ) ;
  82. }
  83.  
  84. void  FINclose( fin )
  85.   register FIN *fin ;
  86. {
  87.   if ( ! (fin->flags & MAIN_FLAG) )  
  88.         zfree(fin->buff, BUFFSZ+1) ;
  89.  
  90.   if ( fin->fd )  
  91.         if ( fin->fp )  (void) fclose(fin->fp) ;
  92.         else  (void) close(fin->fd) ;
  93.  
  94.   zfree( fin , sizeof(FIN) ) ;
  95. }
  96.  
  97. /* return one input record as determined by RS,
  98.    from input file (FIN)  fin
  99. */
  100.  
  101. char *FINgets( fin, len_p )
  102.   FIN *fin ;
  103.   unsigned *len_p ;
  104. { register char *p, *q ;
  105.   unsigned match_len ;
  106.   unsigned r ;
  107.  
  108. restart :
  109.  
  110.   if ( ! (p = fin->buffp)[0] )  /* need a refill */
  111.   { 
  112.     if ( fin->flags & EOF_FLAG )
  113.         if ( (fin->flags & MAIN_FLAG) && next_main() )  goto restart ;
  114.         else
  115.         { *len_p = 0 ; return (char *) 0 ; }
  116.         
  117.     if ( fin->fp ) /* line buffering */
  118.       if ( ! fgets(fin->buff, BUFFSZ+1, fin->fp) )
  119.       {
  120.         fin->flags |= EOF_FLAG ;
  121.         fin->buff[0] = 0 ;
  122.         fin->buffp = fin->buff ;
  123.         goto restart ;  /* might be main_fin */
  124.       }
  125.       else  /* return this line */
  126.       {
  127.         if ( !(p = strchr(fin->buff, '\n')) )
  128.              p = fin->buff + BUFFSZ + 1 ; /* unlikely to occur */
  129.  
  130.         *p = 0 ; *len_p = p - fin->buff ;
  131.         fin->buffp = p ;
  132.         return  fin->buff ;
  133.       }
  134.     else  /* block buffering */
  135.     {
  136.       if ( (r = fillbuff(fin->fd, fin->buff, BUFFSZ)) == 0 )
  137.       {
  138.         fin->flags |= EOF_FLAG ;
  139.         fin->buffp = fin->buff ;
  140.         goto restart ; /* might be main */
  141.       }
  142.       else
  143.       if ( r < BUFFSZ )  fin->flags |= EOF_FLAG ;
  144.  
  145.       p = fin->buffp = fin->buff ;
  146.     }
  147.   }
  148.  
  149. retry: 
  150.  
  151.   switch( rs_shadow.type )
  152.   {
  153.     case SEP_CHAR :
  154.             q = strchr(p, rs_shadow.c) ;
  155.             match_len = 1 ;
  156.             break ;
  157.  
  158.     case SEP_STR  :
  159.             q = str_str(p, ((STRING *) rs_shadow.ptr)->str,
  160.                 match_len = ((STRING *) rs_shadow.ptr)->len ) ;
  161.             break ;
  162.  
  163.     case SEP_RE :
  164.             q = re_pos_match(p, rs_shadow.ptr, &match_len) ;
  165.             /* if the match is at the end, there might be more
  166.                still to be read */
  167.             if ( q && q[match_len] == 0 &&
  168.                  p != fin->buff )  q = (char *) 0 ;
  169.             break ;
  170.             
  171.     default :
  172.             bozo("type of rs_shadow") ;
  173.   }
  174.   if ( q )
  175.   {  /* the easy and normal case */
  176.      *q = 0 ;  *len_p = q - p ;
  177.      fin->buffp = q + match_len  ;
  178.      return p ;
  179.   }
  180.  
  181.   if ( p == fin->buff )  /* last line or one huge (truncated) line */
  182.   { *len_p = r = strlen(p) ;  fin->buffp = p + r ;
  183.     /* treat truncated case as overflow */
  184.     if ( r == BUFFSZ ) 
  185.     { /* overflow, update NR and FNR */
  186.       cast2_to_d(bi_vars+NR) ;
  187.       bi_vars[NR].dval += 1.0 ;
  188.       bi_vars[FNR].dval += 1.0 ;
  189.       rt_overflow("maximum record length" , BUFFSZ) ;
  190.     }
  191.      return p ;
  192.   }
  193.  
  194.   /* move a partial line to front of buffer and try again */
  195.   p = (char *) memcpy( fin->buff, p, r = strlen(p) ) ;
  196.   q = p+r ; 
  197.   if ( fin->flags & EOF_FLAG ) *q = 0 ;
  198.   else 
  199.   { unsigned rr = BUFFSZ - r ;
  200.  
  201.     if ( (r = fillbuff(fin->fd, q, rr)) < rr ) fin->flags |= EOF_FLAG ;
  202.   }
  203.   goto retry ;
  204. }
  205.  
  206. /*--------
  207.   target is big enough to hold size + 1 chars 
  208.   on exit the back of the target is zero terminated
  209.  *--------------*/
  210. unsigned  fillbuff(fd, target, size)
  211.   int fd ;
  212.   register char *target ;
  213.   unsigned size ;
  214. { register int r ;
  215.   unsigned entry_size = size ;
  216.  
  217.   while ( size )
  218.     switch( r = read(fd, target, size) )
  219.     { case -1 :
  220.         errmsg(errno, "read error on file") ;
  221.         exit(1) ;
  222.  
  223.       case 0 :
  224.         goto out ;
  225.  
  226.       default :
  227.         target += r ; size -= r ;
  228.         break ;
  229.     }
  230.  
  231. out :
  232.   *target = 0 ;
  233.   return  entry_size - size ;
  234. }
  235.  
  236. /* main_fin is a handle to the main input stream
  237.    == -1 if never tried to open 
  238.    == 0  if end of stream
  239.       otherwise active    */
  240. FIN *main_fin = (FIN *) -1 ;
  241. ARRAY   Argv ;   /* to the user this is ARGV  */
  242. static int argi = 1 ;  /* index of next ARGV[argi] to try to open */
  243.  
  244. int  open_main()  /* boolean return, true if main is open */
  245. { 
  246.   if ( bi_vars[ARGC].type == C_DOUBLE && bi_vars[ARGC].dval == 1.0 )
  247.   { cell_destroy( bi_vars + FILENAME ) ;
  248.     bi_vars[FILENAME].type = C_STRING ;
  249.     bi_vars[FILENAME].ptr = (PTR) new_STRING( "-") ;
  250.     main_fin = FINdopen(0, 1) ;
  251.     return  1 ;
  252.   }
  253.   else    return next_main() ;
  254. }
  255.  
  256. static  int  next_main()
  257. { char xbuff[16] ;
  258.   register CELL *cp ;
  259.   STRING *sval ;
  260.   CELL   argc ;  /* temp copy of ARGC */
  261.   CELL   tc ;    /* copy of ARGV[argi] */
  262.   double d_argi ;
  263.  
  264. #ifdef  DEBUG
  265.   if ( ! main_fin ) bozo("call to next_main with dead main") ;
  266. #endif
  267.  
  268.   tc.type = C_NOINIT ;
  269.  
  270.   if ( main_fin != (FIN *)-1 )  FINclose(main_fin) ;
  271.   cell_destroy( bi_vars + FILENAME ) ;
  272.   cell_destroy( bi_vars + FNR ) ;
  273.   bi_vars[FNR].type = C_DOUBLE ;
  274.   bi_vars[FNR].dval = 0.0 ;
  275.  
  276.   if ( cellcpy(&argc, &bi_vars[ARGC])->type != C_DOUBLE )
  277.           cast1_to_d(&argc) ;
  278.   xbuff[1] = 0 ;
  279.   d_argi = (double) argi ;
  280.  
  281.   while ( d_argi < argc.dval )
  282.   {
  283.     if ( argi < 10 )  xbuff[0] = argi + '0' ;
  284.     else  (void) sprintf(xbuff, "%u", argi) ;
  285.  
  286.     argi++ ; d_argi += 1.0 ;
  287.     sval = new_STRING(xbuff) ;
  288.  
  289.     /* the user might have changed ARGC or deleted 
  290.        ARGV[argi] -- test for existence without side effects */
  291.     
  292.     if ( ! array_test(Argv, sval) )
  293.     { free_STRING(sval) ; continue ; }
  294.  
  295.     cp = array_find( Argv, sval, 0) ;
  296.     free_STRING(sval) ;
  297.  
  298.     /* make a copy so we can cast w/o side effect */
  299.     cell_destroy(&tc) ;
  300.     cp = cellcpy(&tc, cp) ;
  301.     if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  302.     if ( string(cp)->len == 0 )  continue ;
  303.  
  304.     if ( string(cp)->len == 1 && string(cp)->str[0] == '-' )
  305.     { /* input from stdin */
  306.       main_fin = FINdopen(0,1) ;
  307.     }
  308.     else  /* it might be a command line assignment */
  309.     if ( is_cmdline_assign(string(cp)->str) )  continue ;
  310.  
  311.     else /* try to open it */
  312.     if ( ! (main_fin = FINopen( string(cp)->str, 1 )) ) continue ;
  313.  
  314.     /* success */
  315.     (void) cellcpy( &bi_vars[FILENAME] , cp ) ;
  316.     free_STRING( string(cp) ) ;
  317.     return 1 ;
  318.   }
  319.   /* failure */
  320.   bi_vars[FILENAME].type = C_STRING ;
  321.   bi_vars[FILENAME].ptr = (PTR) new_STRING( "" ) ;
  322.   main_fin = (FIN *) 0 ;
  323.   cell_destroy(&tc) ;
  324.   return 0 ;
  325. }
  326.     
  327.  
  328. static int is_cmdline_assign(s)
  329.   char *s ;
  330. { char *q;
  331.   unsigned char *p ;
  332.   int c ;
  333.   SYMTAB *stp ;
  334.   CELL *cp ;
  335.  
  336.   if ( scan_code[*(unsigned char *)s] != SC_IDCHAR 
  337.        || !(q = strchr(s,'=')) ) return 0 ;
  338.  
  339.   p = (unsigned char *)s+1 ;
  340.   while ( (c = scan_code[*p]) == SC_IDCHAR || c == SC_DIGIT ) p++ ;
  341.  
  342.   if ( (char *)p < q )  return 0 ;
  343.  
  344.   *q = 0 ;
  345.   stp = find(s) ;
  346.  
  347.   switch( stp->type )
  348.   {
  349.     case  ST_NONE :
  350.         stp->type = ST_VAR ;
  351.         stp->stval.cp = cp = new_CELL() ;
  352.         break ;
  353.  
  354.     case  ST_VAR :
  355.         cp = stp->stval.cp ;
  356.         break ;
  357.  
  358.     default :
  359.         rt_error(
  360.           "cannot command line assign to %s\n\t- type clash or keyword" 
  361.           , s ) ;
  362.   }
  363.   
  364.   *q++ = '=' ;
  365.   cp->ptr = (PTR) new_STRING(q) ;
  366.   check_strnum(cp) ;
  367.   return 1 ;
  368. }
  369.